/****************************************************************************
* MINILOGO - Minimalistic Logo Interpreter
* Copyright (C) 1999-2008 Willian Mitsuda
* 
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* 
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
* 
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
* 
*****************************************************************************

*****************************************************************************
* COMANDOS.C                                                                *
*****************************************************************************
* Contem as implementacoes dos comandos basicos do MINI-LOGO                *
****************************************************************************/
#include <stdio.h>    // Necessario p/ sprintf()
#include <math.h>     // Funcoes matematicas
#include <grx20.h>    // Funcoes graficas
#include <grxkeys.h>  // Codigos de teclas
#include "minilogo.h" // Interface de interacao com o ambiente grafico

// Defines locais...
#define INICL  GFG // Valor inicial da cor do "lapis"
#define INICB  GBG // Valor inicial da cor da "borracha"
#define INIDIR 90  // Direcao inicial da tartaruga
#define INIEST 1   // Estilo inicial da tartaruga

#define TATCOLOR (15 | GrXOR) // Cor da tartaruga

// Dados sobre a tartaruga
static float x = 0;         // Coordenada x da tartaruga
static float y = 0;         // Coordenada y da tartaruga
static int dir = INIDIR;    // Direcao da tartaruga
static int vis = 1;         // Tartaruga visivel?
static int estilo = INIEST; // Estilo da tartaruga

// Dados sobre a paleta de cores:
// a primeira posicao deve ser reservada para a cor invisivel;
// portanto sera ignorada...
// a segunda posicao esta reservada para o "lapis"...
// a terceira posicao esta reservada para a "borracha"...
static GrColor cores[3] = {0, INICL, INICB}; // Paleta de cores da tartaruga
static unsigned char colori = 1;             // Cor selecionada

/****************************************************************************
* static void rotpoint(float xi, float yi, float *xf, float *yf)            *
*****************************************************************************
* Rotaciona um ponto xi, yi em torno da posicao atual                       *
*****************************************************************************
* Parametros:                                                               *
*   float xi, yi   - Coordenadas (x, y) do ponto inicial                    *
*   float *xf, *yf - Coordenadas (x, y) resultantes                         *
****************************************************************************/
static void rotpoint(float xi, float yi, float *xf, float *yf)
{
  // Seno e cosseno do angulo de rotacao...
  float s = sin(RAD(dir)), c = cos(RAD(dir));

  // Calcula as resultantes...
  xi -= x;
  yi -= y;
  *xf = x + xi * c - yi * s;
  *yf = y + xi * s + yi * c;
}

/****************************************************************************
* static void showtat(void)                                                 *
*****************************************************************************
* Exibe/esconde a tartaruga                                                 *
****************************************************************************/
static void showtat(void)
{
  // Se invisivel, nao desenha e retorna...
  if(!vis) return;

  // Desenha a tartaruga atraves da funcao rotpoint...
  switch(estilo)
  {
    case 0: // Estilo Seta...
      {
        float pmx, pmy, pex, pey, pdx, pdy;

        rotpoint(x + 25, y, &pmx, &pmy);
        rotpoint(x, y + 10, &pex, &pey);
        rotpoint(x, y - 10, &pdx, &pdy);

        line(pmx, pmy, pex, pey, TATCOLOR);
        line(pmx, pmy, pdx, pdy, TATCOLOR);
        line(pex, pey, pdx, pdy, TATCOLOR);
      }
      break;
    case 1: // Estilo Normal...
      // Circulo exterior...
      {
        float pesx, pesy, peix, peiy;
        float pdsx, pdsy, pdix, pdiy;
        float psex, psey, psdx, psdy;
        float piex, piey, pidx, pidy;

        rotpoint(x + 6, y + 10, &pesx, &pesy);
        rotpoint(x - 6, y + 10, &peix, &peiy);
        rotpoint(x + 6, y - 10, &pdsx, &pdsy);
        rotpoint(x - 6, y - 10, &pdix, &pdiy);

        rotpoint(x + 10, y + 6, &psex, &psey);
        rotpoint(x + 10, y - 6, &psdx, &psdy);
        rotpoint(x - 10, y + 6, &piex, &piey);
        rotpoint(x - 10, y - 6, &pidx, &pidy);

        line(pesx, pesy, peix, peiy, TATCOLOR);
        line(pdsx, pdsy, pdix, pdiy, TATCOLOR);
        line(psex, psey, psdx, psdy, TATCOLOR);
        line(piex, piey, pidx, pidy, TATCOLOR);

        line(pesx, pesy, psex, psey, TATCOLOR);
        line(pdsx, pdsy, psdx, psdy, TATCOLOR);
        line(peix, peiy, piex, piey, TATCOLOR);
        line(pdix, pdiy, pidx, pidy, TATCOLOR);
      }
      // Cauda...
      {
        float pmx, pmy, pex, pey, pdx, pdy;

        rotpoint(x - 15, y, &pmx, &pmy);
        rotpoint(x - 11, y + 3, &pex, &pey);
        rotpoint(x - 11, y - 3, &pdx, &pdy);

        line(pmx, pmy, pex, pey, TATCOLOR);
        line(pmx, pmy, pdx, pdy, TATCOLOR);
      }
      // Cabeca...
      {
        float peix, peiy, pesx, pesy;
        float pdix, pdiy, pdsx, pdsy;

        rotpoint(x + 11, y + 3, &peix, &peiy);
        rotpoint(x + 16, y + 3, &pesx, &pesy);
        rotpoint(x + 11, y - 3, &pdix, &pdiy);
        rotpoint(x + 16, y - 3, &pdsx, &pdsy);

        line(peix, peiy, pesx, pesy, TATCOLOR);
        line(pdix, pdiy, pdsx, pdsy, TATCOLOR);
        line(pesx, pesy, pdsx, pdsy, TATCOLOR);
      }
      // Patas...
      {
        float piex, piey, pidx, pidy;
        float peex, peey, pedx, pedy;
        int h, v;

        for(h = -1; h <= 1; h += 2)
          for(v = -1; v <= 1; v += 2)
          {
            rotpoint(x + v * 6, y + h * 10, &piex, &piey);
            rotpoint(x + v * 10, y + h * 6, &pidx, &pidy);
            rotpoint(x + v * 9, y + h * 13, &peex, &peey);
            rotpoint(x + v * 13, y + h * 9, &pedx, &pedy);

            line(piex, piey, peex, peey, TATCOLOR);
            line(pidx, pidy, pedx, pedy, TATCOLOR);
            line(peex, peey, pedx, pedy, TATCOLOR);
          }
      }
      break;
    case 2: // Estilo Complexo...
      // Corpo...
      {
        int h, v;

        // Tracos Centrais...
        for(h = -1; h <= 1; h += 2)
        {
          float pcix, pciy, pcex, pcey;

          rotpoint(x, y + h * 10, &pcix, &pciy);
          rotpoint(x, y + h * 15, &pcex, &pcey);

          line(pcix, pciy, pcex, pcey, TATCOLOR);
        }
        for(v = -1; v <= 1; v += 2)
        {
          float phx[6], phy[6];

          rotpoint(x + v * 18, y + 8, &phx[0], &phy[0]);
          rotpoint(x + v * 15, y + 5, &phx[1], &phy[1]);
          rotpoint(x + v * 5, y + 5, &phx[2], &phy[2]);

          rotpoint(x + v * 18, y - 8, &phx[3], &phy[3]);
          rotpoint(x + v * 15, y - 5, &phx[4], &phy[4]);
          rotpoint(x + v * 5, y - 5, &phx[5], &phy[5]);

          for(h = 0; h < 3; h++)
            line(phx[h], phy[h], phx[h + 3], phy[h + 3], TATCOLOR);
        }

        // Tracos Internos...
        for(h = -1; h <= 1; h += 2)
        {
          float picx, picy, pecx, pecy;

          // Pontos Centrais...
          rotpoint(x, y + h * 10, &picx, &picy);
          rotpoint(x, y + h * 15, &pecx, &pecy);

          for(v = -1; v <= 1; v += 2)
          {
            float px[5], py[5];
            int k;

            rotpoint(x + v * 5, y + h * 5, &px[0], &py[0]);
            rotpoint(x + v * 10, y + h * 10, &px[1], &py[1]);
            rotpoint(x + v * 15, y + h * 5, &px[2], &py[2]);
            rotpoint(x + v * 18, y + h * 9, &px[3], &py[3]);
            rotpoint(x + v * 13, y + h * 13, &px[4], &py[4]);

            line(px[0], py[0], picx, picy, TATCOLOR);
            for(k = 0; k <= 3; k++)
              line(px[k], py[k], px[k + 1], py[k + 1], TATCOLOR);
            line(px[4], py[4], pecx, pecy, TATCOLOR);
            line(px[4], py[4], px[1], py[1], TATCOLOR);
          }
        }
      }
      // Cabeca...
      {
        float peix, peiy, pemx, pemy, pesx, pesy;
        float pdix, pdiy, pdmx, pdmy, pdsx, pdsy;

        rotpoint(x + 19, y + 3, &peix, &peiy);
        rotpoint(x + 25, y + 4, &pemx, &pemy);
        rotpoint(x + 28, y + 2, &pesx, &pesy);
        rotpoint(x + 19, y - 3, &pdix, &pdiy);
        rotpoint(x + 25, y - 4, &pdmx, &pdmy);
        rotpoint(x + 28, y - 2, &pdsx, &pdsy);

        line(peix, peiy, pemx, pemy, TATCOLOR);
        line(pemx, pemy, pesx, pesy, TATCOLOR);
        line(pdix, pdiy, pdmx, pdmy, TATCOLOR);
        line(pdmx, pdmy, pdsx, pdsy, TATCOLOR);
        line(pesx, pesy, pdsx, pdsy, TATCOLOR);
      }
      // Cauda...
      {
        float pex, pey, pdx, pdy, pmx, pmy;

        rotpoint(x - 19, y + 4, &pex, &pey);
        rotpoint(x - 19, y - 4, &pdx, &pdy);
        rotpoint(x - 28, y, &pmx, &pmy);

        line(pmx, pmy, pex, pey, TATCOLOR);
        line(pmx, pmy, pdx, pdy, TATCOLOR);
      }
      // Patas...
      {
        float px[8], py[8];
        int h, k;

        for(h = -1; h <= 1; h += 2)
        {
          rotpoint(x + 18, y + h * 10, &px[0], &py[0]);
          rotpoint(x + 23, y + h * 12, &px[1], &py[1]);
          rotpoint(x + 8, y + h * 22, &px[2], &py[2]);
          rotpoint(x + 15, y + h * 13, &px[3], &py[3]);

          rotpoint(x - 15, y + h * 13, &px[4], &py[4]);
          rotpoint(x - 33, y + h * 16, &px[5], &py[5]);
          rotpoint(x - 28, y + h * 10, &px[6], &py[6]);
          rotpoint(x - 17, y + h * 9, &px[7], &py[7]);

          for(k = 0; k < 3; k++)
          {
            line(px[k], py[k], px[k + 1], py[k + 1], TATCOLOR);
            line(px[k + 4], py[k + 4], px[k + 5], py[k + 5], TATCOLOR);
          }
        }
      }
      break;
  }
}

/****************************************************************************
* static cmd_stat anda(int r, int k)                                        *
*****************************************************************************
* Funcao auxiliar para a implementacao dos comandos PF e PT                 *
* Move a tartaruga um determinado numero de passos para frente ou para tras *
*****************************************************************************
* Parametros:                                                               *
*   int r - A distancia a ser percorrida                                    *
*   int k - Deve ser: 1 - p/ frente / -1 - p/ tras                          *
*****************************************************************************
* Retorna:                                                                  *
*   O status do comando, que eh repassado pela funcao tratadora             *
****************************************************************************/
static cmd_stat anda(int r, int k)
{
  // Se o numero de passos nao for 0, calcula o destino e desenha...
  if(r != 0)
  {
    // Apaga a tartaruga se necessario...
    showtat();

    // Desenha um traco da posicao atual a uma distancia r - 1 calculada...
    if(colori != 0)
    {
      float xf = x + k * (r - 1) * cos(RAD(dir)); // Destino X...
      float yf = y + k * (r - 1) * sin(RAD(dir)); // Destino Y...
      line(x, y, xf, yf, cores[colori]);
    }

    // Posiciona x e y a uma distancia r da posicao atual...
    x += k * r * cos(RAD(dir));
    transX(&x);
    y += k * r * sin(RAD(dir));
    transY(&y);

    // Redesenha a tartaruga se necessario...
    showtat();
  }
  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat pf(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando PF                                               *
* Move a tartaruga um determinado numero de passos para frente              *
****************************************************************************/
cmd_stat pf(char *args[])
{
  return(anda(atoi(args[0]), 1));
}

/****************************************************************************
* cmd_stat pt(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando PT                                               *
* Move a tartaruga um determinado numero de passos para tras                *
****************************************************************************/
cmd_stat pt(char *args[])
{
  return(anda(atoi(args[0]), -1));
}

/****************************************************************************
* static cmd_stat gira(int a, int k)                                        *
*****************************************************************************
* Funcao auxiliar para a implementacao dos comandos PE e PD                 *
* Gira a tartaruga um determinado angulo para a direita ou esquerda         *
*****************************************************************************
* Parametros:                                                               *
*   int a - O angulo a ser adicionado                                       *
*   int k - Deve ser: 1 - p/ esquerda / -1 - p/ direita                     *
*****************************************************************************
* Retorna:                                                                  *
*   O status do comando, que eh repassado pela funcao tratadora             *
****************************************************************************/
static cmd_stat gira(int a, int k)
{
  // Apaga a tartaruga se necessario...
  showtat();

  // Encontra o angulo equivalente dentro da faixa -359 - 359...
  a %= 360;

  // Adiciona o angulo a direcao atual...
  dir += k * a;

  // Encontra a resultante equivalente dentro da faixa -359 - 359...
  a %= 360;

  // Redesenha a tartaruga se necessario...
  showtat();

  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat pd(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando PD                                               *
* Gira a tartaruga um determinado angulo a direita                          *
****************************************************************************/
cmd_stat pd(char *args[])
{
  return(gira(atoi(args[0]), -1));
}

/****************************************************************************
* cmd_stat pe(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando PE                                               *
* Gira a tartaruga um determinado angulo a esquerda                         *
****************************************************************************/
cmd_stat pe(char *args[])
{
  return(gira(atoi(args[0]), 1));
}

/****************************************************************************
* cmd_stat pc(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando PC                                               *
* Move a tartaruga para a origem                                            *
****************************************************************************/
cmd_stat pc(char *args[])
{
  // r eh a distancia da posicao atual ate a origem...
  float r = sqrt(pow(x, 2) + pow(y, 2));

  // Apaga a tartaruga se necessario...
  showtat();

  // Se a distancia != 0, traca a linha da posicao atual ate a origem...
  if(colori != 0 && round(r) != 0)
  {
    float xf = x + (r - 1) * (-x / r); // Destino X...
    float yf = y + (r - 1) * (-y / r); // Destino Y...
    line(x, y, xf, yf, cores[colori]);
  }

  // Posiciona a tartaruga na origem...
  x = y = 0;

  // Redesenha a tartaruga se necessario...
  showtat();

  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat repita(char *args[])                                             *
*****************************************************************************
* Implementacao do comando REPITA                                           *
* Repete um determinado numero de vezes um bloco de comandos                *
****************************************************************************/
cmd_stat repita(char *args[])
{
  int n = atoi(args[0]); // Extrai o numero de repeticoes...
  int i = 0;             // Contador de repeticoes...
  cmd_stat ret;          // Status retornado pelo comando executado...

  // Se n nao for positivo, ERRO!!!
  if(n <= 0)
  {
    printline("O primeiro argumento deve ser maior que 0!!!", SERR);
    return(S_erro);
  }

  // Executa o bloco enquanto nao atingir o numero de repeticoes
  // requisitado e o status do ultimo comando executado for igual a ok...
  do
  {
    ret = parse(args[1]);
    i++;
  } while(i < n && ret == S_ok);
  return(ret); // Retorna o status do ultimo comando executado...
}

/****************************************************************************
* static cmd_stat movexy(int newX, int newY)                                *
*****************************************************************************
* Funcao auxiliar para a implementacao dos comandos MUDEX, MUDEY e MUDEXY   *
* Move a tartaruga para a posicao x, y indicada, mantendo as demais         *
* definicoes e propriedades da tartaruga inalteradas                        *
*****************************************************************************
* Parametros:                                                               *
*   int newX - Nova coordenada x                                            *
*   int newY - Nova coordenada y                                            *
*****************************************************************************
* Retorna:                                                                  *
*   O status do comando, que eh repassado pela funcao tratadora             *
****************************************************************************/
static cmd_stat movexy(int newX, int newY)
{
  float r = sqrt(pow(newX - x, 2) + pow(newY - y, 2));

  // Se a posicao x ultrapassar os limites da tela, ERRO!!!
  if(newX < GXMIN || newX > GXMAX)
  {
    char buffer[100];
    sprintf(buffer, "A posicao x deve estar entre: %d e %d", GXMIN, GXMAX);
    printline(buffer, SERR);
    return(S_erro);
  }

  // Se a posicao y ultrapassar os limites da tela, ERRO!!!
  if(newY < GYMIN || newY > GYMAX)
  {
    char buffer[100];
    sprintf(buffer, "A posicao y deve estar entre %d e %d", GYMIN, GYMAX);
    printline(buffer, SERR);
    return(S_erro);
  }

  // Tudo ok...
  // Apaga a tartaruga se necessario...
  showtat();

  // Traca a reta...
  if(colori != 0 && r != 0)
  {
    float xf = x + (r - 1) * ((newX - x) / r); // Destino X...
    float yf = y + (r - 1) * ((newY - y) / r); // Destino Y...
    line(x, y, xf, yf, cores[colori]);
  }

  // Reposiciona x e y...
  x = newX;
  y = newY;

  // Redesenha a tartaruga se necessario...
  showtat();

  return(S_ok);
}

/****************************************************************************
* cmd_stat mudex(char *args[])                                              *
*****************************************************************************
* Implementacao do comando MUDEX                                            *
* Move a tartaruga para a posicao x indicada, mantendo as demais            *
* definicoes                                                                *
****************************************************************************/
cmd_stat mudex(char *args[])
{
  return(movexy(atoi(args[0]), round(y)));
}

/****************************************************************************
* cmd_stat mudey(char *args[])                                              *
*****************************************************************************
* Implementacao do comando MUDEY                                            *
* Move a tartaruga para a posicao y indicada, mantendo as demais            *
* definicoes                                                                *
****************************************************************************/
cmd_stat mudey(char *args[])
{
  return(movexy(round(x), atoi(args[0])));
}

/****************************************************************************
* cmd_stat mudexy(char *args[])                                             *
*****************************************************************************
* Implementacao do comando MUDEXY                                           *
* Move a tartaruga para a posicao x, y indicada, mantendo as demais         *
* definicoes                                                                *
****************************************************************************/
cmd_stat mudexy(char *args[])
{
  return(movexy(atoi(args[0]), atoi(args[1])));
}

/****************************************************************************
* cmd_stat ad(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando AD                                               *
* Apaga o desenho atual, mas mantem a posicao, direcao, e paleta de cores   *
* atuais da tartaruga                                                       *
****************************************************************************/
cmd_stat ad(char *args[])
{
  clgr();       // Limpa a janela grafica...
  showtat();    // Redesenha a tartaruga se necessario...
  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat att(char *args[])                                                *
*****************************************************************************
* Implementacao do comando ATT                                              *
* Limpa a janela do shell                                                   *
****************************************************************************/
cmd_stat att(char *args[])
{
  clsh();       // Limpa a janela do shell...
  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat tat(char *args[])                                                *
*****************************************************************************
* Implementacao do comando TAT                                              *
* "Reinicia" a janela grafica                                               *
****************************************************************************/
cmd_stat tat(char *args[])
{
  clgr(); // Limpa a janela grafica...
  clsh(); // Limpa a janela do shell...

  // Reinicializa as definicoes padrao da tartaruga...
  x = y = 0;
  dir = INIDIR;
  vis = 1;
  colori = 1;
  cores[1] = INICL;
  cores[2] = INICB;

  showtat();    // Redesenha a tartaruga...
  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat at(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando AT                                               *
* Faz a tartaruga aparecer                                                  *
****************************************************************************/
cmd_stat at(char *args[])
{
  if(!vis) // Se ja estiver visivel, sai...
  {
    vis = 1;   // Ativa visibilidade...
    showtat(); // Desenha a tartaruga na posicao e direcao atual...
  }
  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat dt(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando DT                                               *
* Faz a tartaruga desaparecer                                               *
****************************************************************************/
cmd_stat dt(char *args[])
{
  if(vis) // Se ja estiver invisivel, sai...
  {
    showtat(); // Faz a tartaruga desaparecer...
    vis = 0;   // Ativa invisibilidade...
  }
  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat estt(char *args[])                                               *
*****************************************************************************
* Implementacao do comando ESTT                                             *
* Altera o estilo da tartaruga                                              *
****************************************************************************/
cmd_stat estt(char *args[])
{
  int e = atoi(args[0]); // Extrai o estilo...

  // O estilo deve estar entre 0 e 2...
  if(e >= 0 && e <= 2)
  {
    showtat();    // Apaga a tartaruga se necessario...
    estilo = e;   // Atribui o novo estilo...
    showtat();    // Redesenha a tartaruga no novo estilo, se necessario...
    return(S_ok); // Retorna o status ok...
  }
  else
  {
    printline("O primeiro parametro deve ser 0, 1 ou 2", SERR);
    return(S_erro); // Retorna o status erro...
  }
}

/****************************************************************************
* static cmd_stat mudecor(int cor, int i)                                   *
*****************************************************************************
* Funcao auxiliar para a implementacao dos comandos MUDECx                  *
*****************************************************************************
* Parametros:                                                               *
*   int cor - O codigo da nova cor                                          *
*   int i   - O indice da paleta de cores a ser alterada                    *
*****************************************************************************
* Retorna:                                                                  *
*   O status do comando, que eh repassado pela funcao tratadora             *
****************************************************************************/
static cmd_stat mudecor(int cor, int i)
{
  // Se a cor nao estiver entre 0 e 15, ERRO!!!; caso contrario, atribui
  // a cor ao indice especificado...
  if(cor >= 0 && cor <= 15)
  {
    cores[i] = cor; // Armazena a cor no indice especificado...
    return(S_ok);   // Retorna o status ok...
  }
  else
  {
    printline("O parametro cor deve estar entre 0 e 15!!!", SERR);
    return(S_erro); // Retorna o status erro...
  }
}

/****************************************************************************
* cmd_stat mudecl(char *args[])                                             *
*****************************************************************************
* Implementacao do comando MUDECL                                           *
* Muda a "cor do lapis" (o indice 1 da paleta de cores)                     *
****************************************************************************/
cmd_stat mudecl(char *args[])
{
  return(mudecor(atoi(args[0]), 1));
}

/****************************************************************************
* cmd_stat mudecb(char *args[])                                             *
*****************************************************************************
* Implementacao do comando MUDECB                                           *
* Muda a "cor da borracha" (o indice 2 da paleta de cores)                  *
****************************************************************************/
cmd_stat mudecb(char *args[])
{
  return(mudecor(atoi(args[0]), 2));
}

/****************************************************************************
* static cmd_stat ativacor(unsigned char i)                                 *
*****************************************************************************
* Funcao auxiliar para a implementacao dos comandos UL, UB, UN              *
*****************************************************************************
* Parametros:                                                               *
*   unsigned char i - Indice a ser ativado                                  *
*****************************************************************************
* Retorna:                                                                  *
*   O status do comando, que eh repassado pela funcao tratadora             *
****************************************************************************/
static cmd_stat ativacor(unsigned char i)
{
  colori = i;   // Ativa o indice especificado...
  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat ul(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando UL                                               *
* "Use Lapis" (seleciona a cor 1 da paleta de cores)                        *
****************************************************************************/
cmd_stat ul(char *args[])
{
  return(ativacor(1));
}

/****************************************************************************
* cmd_stat ub(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando UB                                               *
* "Use Borracha" (seleciona a cor 2 da paleta de cores)                     *
****************************************************************************/
cmd_stat ub(char *args[])
{
  return(ativacor(2));
}

/****************************************************************************
* cmd_stat un(char *args[])                                                 *
*****************************************************************************
* Implementacao do comando UN                                               *
* "Use Nada" (seleciona a cor constante "invisivel" 0 da paleta de cores)   *
****************************************************************************/
cmd_stat un(char *args[])
{
  return(ativacor(0));
}

/****************************************************************************
* static cmd_stat mostrestri(char *format, int v)                           *
*****************************************************************************
* Emite uma saida formatada de um valor int                                 *
*****************************************************************************
* Parametros:                                                               *
*   char *format - A string de formato utilizada por sprintf()              *
*   int v        - O valor int                                              *
****************************************************************************/
static cmd_stat mostrestri(char *format, int v)
{
  char buffer[100]; // Buffer de saida...

  // Envia a saida formatada...
  sprintf(buffer, format, v);
  printline(buffer, SINF);

  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* static cmd_stat mostrestrf(char *format, float v)                         *
*****************************************************************************
* Emite uma saida formatada de um valor float                               *
*****************************************************************************
* Parametros:                                                               *
*   char *format - A string de formato utilizada por sprintf()              *
*   float v      - O valor float                                            *
****************************************************************************/
static cmd_stat mostrestrf(char *format, float v)
{
  char buffer[100]; // Buffer de saida...

  // Envia a saida formatada...
  sprintf(buffer, format, v);
  printline(buffer, SINF);

  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat mostrex(char *args[])                                            *
*****************************************************************************
* Implementacao do comando MOSTREX                                          *
* Exibe a posicao X da tartaruga                                            *
****************************************************************************/
cmd_stat mostrex(char *args[])
{
  return(mostrestrf("Posicao X: %.2f", x));
}

/****************************************************************************
* cmd_stat mostrey(char *args[])                                            *
*****************************************************************************
* Implementacao do comando MOSTREY                                          *
* Exibe a posicao Y da tartaruga                                            *
****************************************************************************/
cmd_stat mostrey(char *args[])
{
  return(mostrestrf("Posicao Y: %.2f", y));
}

/****************************************************************************
* cmd_stat mostrexy(char *args[])                                           *
*****************************************************************************
* Implementacao do comando MOSTREXY                                         *
* Mostra a posicao (X, Y) da tartaruga                                      *
****************************************************************************/
cmd_stat mostrexy(char *args[])
{
  mostrex(args);
  mostrey(args);
  return(S_ok);
}

/****************************************************************************
* cmd_stat mostrexlim(char *args[])                                         *
*****************************************************************************
* Implementacao do comando MOSTREXLIM                                       *
* Exibe os limites inferior e superior do eixo x                            *
****************************************************************************/
cmd_stat mostrexlim(char *args[])
{
  mostrestri("Limite inferior do eixo x: %d", GXMIN);
  mostrestri("Limite superior do eixo x: %d", GXMAX);
  return(S_ok);
}

/****************************************************************************
* cmd_stat mostreylim(char *args[])                                         *
*****************************************************************************
* Implementacao do comando MOSTREYLIM                                       *
* Exibe os limites inferior e superior do eixo y                            *
****************************************************************************/
cmd_stat mostreylim(char *args[])
{
  mostrestri("Limite inferior do eixo y: %d", GYMIN);
  mostrestri("Limite superior do eixo y: %d", GYMAX);
  return(S_ok);
}

/****************************************************************************
* cmd_stat mostrexylim(char *args[])                                        *
*****************************************************************************
* Implementacao do comando MOSTREXYLIM                                      *
* Exibe os limites inferior e superior dos eixos x e y                      *
****************************************************************************/
cmd_stat mostrexylim(char *args[])
{
  mostrexlim(args);
  mostreylim(args);
  return(S_ok);
}

/****************************************************************************
* cmd_stat mostredir(char *args[])                                          *
*****************************************************************************
* Implementacao do comando MOSTREDIR                                        *
* Mostra a direcao da tartaruga                                             *
****************************************************************************/
cmd_stat mostredir(char *args[])
{
  return(mostrestri("Direcao da Tartaruga: %d", dir));
}

/****************************************************************************
* cmd_stat mostreest(char *args[])                                          *
*****************************************************************************
* Implementacao do comando MOSTREEST                                        *
* Exibe o estilo atual da tartaruga                                         *
****************************************************************************/
cmd_stat mostreest(char *args[])
{
  return(mostrestri("Estilo da Tartaruga: %d", estilo));
}

/****************************************************************************
* cmd_stat mostrecl(char *args[])                                           *
*****************************************************************************
* Implementacao do comando MOSTRECL                                         *
* Mostra a cor do lapis                                                     *
****************************************************************************/
cmd_stat mostrecl(char *args[])
{
  return(mostrestri("Cor do Lapis: %u", cores[1]));
}

/****************************************************************************
* cmd_stat mostrecb(char *args[])                                           *
*****************************************************************************
* Implementacao do comando MOSTRECB                                         *
* Mostra a cor da borracha                                                  *
****************************************************************************/
cmd_stat mostrecb(char *args[])
{
  return(mostrestri("Cor da Borracha: %u", cores[2]));
}

/****************************************************************************
* cmd_stat sair(char *args[])                                               *
*****************************************************************************
* Implementacao dos comandos SAIR e FIM                                     *
* Simplesmente exibe uma mensagem de encerramento e retorna o status FIM    *
****************************************************************************/
cmd_stat sair(char *args[])
{
  printline("Saindo do MINI-LOGO...", SMSG);
  return(S_fim);
}

/****************************************************************************
* static void pausa(void)                                                   *
*****************************************************************************
* Funcao auxiliar do comando AJUDA                                          *
* Faz uma pausa entre as telas de ajuda                                     *
****************************************************************************/
static void pausa(void)
{
  // Exibe mensagem...
  printstr("< Pressione qualquer tecla para continuar... >", SMSG);

  GrKeyRead(); // Captura uma tecla...
  newline();   // Avanca a linha...
}

/****************************************************************************
* cmd_stat ajuda(char *args[])                                              *
*****************************************************************************
* Implementacao do comando AJUDA                                            *
* Exibe a ajuda de um determinado comando                                   *
****************************************************************************/
cmd_stat ajuda(char *args[])
{
  // Verifica o comando...
  // PF ou PARAFRENTE...
  if(stricmp(args[0], "pf") == 0 || stricmp(args[0], "parafrente") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("PF numero-de-passos", SCOD);
    printline("         PARAFRENTE numero-de-passos", SCOD);
    printstr("Definicao: ", SMSG);
    printline("O comando PF movimenta a tartaruga um determinado numero de passos   para a frente conforme a sua direcao, deixando  um rastro caso  o lapis ou a   borracha esteja ativada.", SINF);
    pausa();
    printline("Se o numero de passos especificado for negativo, a tartaruga andara para tras.", SINF);
  }
  // PT ou PARATRAS...
  else if(stricmp(args[0], "pt") == 0 || stricmp(args[0], "paratras") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("PT numero-de-passos", SCOD);
    printline("         PARATRAS numero-de-passos", SCOD);
    printstr("Definicao: ", SMSG);
    printline("O comando PT movimenta a tartaruga um determinado numero de passos  para tras conforme a sua direcao, deixando um rastro caso o lapis ou a borracha esteja ativada.", SINF);
    pausa();
    printline("Se o numero de passos especificado for negativo, a tartaruga andara para frente.", SINF);
  }
  // PD ou PARADIREITA...
  else if(stricmp(args[0], "pd") == 0 || stricmp(args[0], "paradireita") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("PD angulo-a-girar", SCOD);
    printline("         PARADIREITA angulo-a-girar", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Gira a tartaruga um determinado numero de graus para a direita.", SINF);
    printline("Se o angulo for negativo, a tartaruga ira girar para a esquerda.", SINF);
  }
  // PE ou PARAESQUERDA...
  else if(stricmp(args[0], "pe") == 0 || stricmp(args[0], "paraesquerda") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("PE angulo-a-girar", SCOD);
    printline("         PARAESQUERDA angulo-a-girar", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Gira a tartaruga um determinado numero de graus para a esquerda.", SINF);
    printline("Se o angulo for negativo, a tartaruga ira girar para a direita.", SINF);
  }
  // PC ou PARACENTRO...
  else if(stricmp(args[0], "pc") == 0 || stricmp(args[0], "paracentro") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("PC", SCOD);
    printline("         PARACENTRO", SCOD);
    printstr("Definicao: ", SMSG);
    printline("O comando PC move a tartaruga para o centro, mantendo a direcao e a paleta de cores atual.", SINF);
  }
  // MUDEX...
  else if(stricmp(args[0], "mudex") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MUDEX coordenada-x", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Move a tartaruga para a posicao no eixo x especificado como primeiro parametro. A posicao y e a direcao atual sera mantida.", SINF);
    printline("Caso o valor especificado esteja fora da faixa permitida, o comando acusara um erro.", SINF);
  }
  // MUDEY...
  else if(stricmp(args[0], "mudey") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MUDEY coordenada-y", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Move a tartaruga para a posicao no eixo y especificado como primeiro parametro. A posicao x e a direcao atual sera mantida.", SINF);
    printline("Caso o valor especificado esteja fora da faixa permitida, o comando acusara um erro.", SINF);
  }
  // MUDEXY...
  else if(stricmp(args[0], "mudexy") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MUDEXY coordenada-x coordenada-y", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Move a tartaruga para a coordenada (x, y) especificada.", SINF);
    printline("Caso algum dos valores especificados esteja fora da faixa permitida, o comando acusara um erro.", SINF);
  }
  // REPITA...
  else if(stricmp(args[0], "repita") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("REPITA numero-de-vezes [bloco-de-comandos-a-ser-repetido]", SCOD);
    printstr("Definicao: ", SMSG);
    printline("O comando REPITA  executa o  bloco de comandos  especificado como    segundo parametro um certo numero de vezes.", SINF);
    printline("A quantidade de repeticoes e definido no primeiro parametro, e deve ser maior   que 0.", SINF);
  }
  // AD ou APAGUEDESENHO...
  else if(stricmp(args[0], "ad") == 0 || stricmp(args[0], "apaguedesenho") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("AD", SCOD);
    printline("         APAGUEDESENHO", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Limpa a janela grafica, mantendo a posicao, a direcao e as demais    propriedades da tartaruga inalteradas.", SINF);
  }
  // ATT ou APAGUETEXTO...
  else if(stricmp(args[0], "att") == 0 || stricmp(args[0], "apaguetexto") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("ATT", SCOD);
    printline("         APAGUETEXTO", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Limpa a janela do interpretador e posiciona o cursor no topo da      janela.", SINF);
  }
  // TAT ou TARTARUGA...
  else if(stricmp(args[0], "tat") == 0 || stricmp(args[0], "tartaruga") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("TAT", SCOD);
    printline("         TARTARUGA", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Limpa a janela grafica, posiciona a tartaruga no centro e            reinicializa todas as suas propriedades, como cor e direcao, para as           definicoes padrao.", SINF);
  }
  // AT ou APARECATAT...
  else if(stricmp(args[0], "at") == 0 || stricmp(args[0], "aparecatat") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("AT", SCOD);
    printline("         APARECATAT", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Faz com que a tartaruga fique visivel.", SINF);
  }
  // DT ou DESAPARECATAT...
  else if(stricmp(args[0], "dt") == 0 || stricmp(args[0], "desaparecatat") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("DT", SCOD);
    printline("         DESAPARECATAT", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Faz com que a tartaruga fique invisivel.", SINF);
  }
  // ESTT ou ESTILOTAT...
  else if(stricmp(args[0], "estt") == 0 || stricmp(args[0], "estilotat") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("ESTT codigo-do-estilo", SCOD);
    printline("         ESTILOTAT codigo-do-estilo", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Altera o estilo da tartaruga. O parametro codigo-do-estilo deve ser um valor entre 0 e 2.", SINF);
    pausa();
    printline("O valor 0 equivale ao estilo \"seta\". O valor 1 equivale ao estilo \"tartaruga   simplificada\". O valor 2 representa o estilo \"tartaruga complexa\".", SINF);
  }
  // MUDECL...
  else if(stricmp(args[0], "mudecl") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MUDECL codigo-da-cor", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Altera a cor do \"lapis\" utilizado pela tartaruga. O parametro codigo-da-cor deve ser um valor entre 0 e 15.", SINF);
  }
  // MUDECB...
  else if(stricmp(args[0], "mudecb") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MUDECB codigo-da-cor", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Altera a cor da \"borracha\" utilizada pela tartaruga. O parametro     codigo-da-cor deve ser um valor entre 0 e 15.", SINF);
  }
  // UL ou USELAPIS...
  else if(stricmp(args[0], "ul") == 0 || stricmp(args[0], "uselapis") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("UL", SCOD);
    printline("         USELAPIS", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Ativa o lapis. Quando a tartaruga se movimentar, deixara um rastro   da cor definida para o lapis.", SINF);
  }
  // UB ou USEBORRACHA...
  else if(stricmp(args[0], "ub") == 0 || stricmp(args[0], "useborracha") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("UB", SCOD);
    printline("         USEBORRACHA", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Ativa a borracha. Quando a tartaruga se movimentar, deixara um       rastro da cor definida para a borracha.", SINF);
  }
  // UN ou USENADA...
  else if(stricmp(args[0], "un") == 0 || stricmp(args[0], "usenada") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("UN", SCOD);
    printline("         USENADA", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Desliga o rastro da tartaruga.", SINF);
  }
  // MOSTREX...
  else if(stricmp(args[0], "mostrex") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTREX", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe a coordenada x da posicao atual da tartaruga.", SINF);
  }
  // MOSTREY...
  else if(stricmp(args[0], "mostrey") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTREY", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe a coordenada y da posicao atual da tartaruga.", SINF);
  }
  // MOSTREXY...
  else if(stricmp(args[0], "mostrexy") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTREXY", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe as coordenadas x e y da posicao atual da tartaruga.", SINF);
  }
  // MOSTREXLIM...
  else if(stricmp(args[0], "mostrexlim") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTREXLIM", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe os limites inferior e superior do eixo x.", SINF);
  }
  // MOSTREYLIM...
  else if(stricmp(args[0], "mostreylim") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTREYLIM", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe os limites inferior e superior do eixo y.", SINF);
  }
  // MOSTREXYLIM...
  else if(stricmp(args[0], "mostrexylim") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTREXYLIM", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe os limites inferior e superior dos eixos x e y.", SINF);
  }
  // MOSTREDIR...
  else if(stricmp(args[0], "mostredir") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTREDIR", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe a direcao para onde a tartaruga esta apontando.", SINF);
  }
  // MOSTREEST...
  else if(stricmp(args[0], "mostreest") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTREEST", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe o estilo atual da tartaruga.", SINF);
  }
  // MOSTRECL...
  else if(stricmp(args[0], "mostrecl") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTRECL", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe a cor atual do lapis.", SINF);
  }
  // MOSTRECB...
  else if(stricmp(args[0], "mostrecb") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("MOSTRECB", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe a cor atual da borracha.", SINF);
  }
  // SAIR...
  else if(stricmp(args[0], "sair") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("SAIR", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Sai do MINI-LOGO e retorna ao DOS.", SINF);
  }
  // AJUDA...
  else if(stricmp(args[0], "ajuda") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("AJUDA nome-do-comando", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe a ajuda on-line de um determinado comando.", SINF);
  }
  // DEMO...
  else if(stricmp(args[0], "demo") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("DEMO", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe uma demonstracao dos recursos do MINI-LOGO.", SINF);
  }
  // SOBRE...
  else if(stricmp(args[0], "sobre") == 0)
  {
    printstr("Sintaxe: ", SMSG);
    printline("SOBRE", SCOD);
    printstr("Definicao: ", SMSG);
    printline("Exibe os creditos do programa.", SINF);
  }
  // ERRO!!!
  else
  {
    printline("Comando nao existente ou nao documentado!!!", SERR);
    return(S_erro); // Retorna o status erro...
  }
  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* static int chkcont(void)                                                  *
*****************************************************************************
* Verifica se o usuario quer continuar a demonstracao                       *
****************************************************************************/
static int chkcont(void)
{
  GrKeyType k;

  // Exibe a mensagem...
  printline("Continuar demonstracao? [ESC] - ENCERRAR / [ENTER] CONTINUAR", SMSG);

  // Captura tecla...
  do
  {
    k = GrKeyRead();
  } while(k != GrKey_Return && k != GrKey_Escape);

  // Retorna 1 se [ENTER], 0 se [ESC]...
  return(k == GrKey_Return);
}

/****************************************************************************
* static void execdemo(char *cmds)                                          *
*****************************************************************************
* Executa uma etapa da demonstracao                                         *
****************************************************************************/
static void execdemo(char *cmds)
{
  // Executa a demonstracao...
  parse(cmds);

  // Exibe a mensagem padrao...
  printstr("Comando: \"", SMSG);
  printstr(cmds, SCOD);
  printline("\"", SMSG);
  newline();
}

/****************************************************************************
* cmd_stat demo(char *args[])                                               *
*****************************************************************************
* Implementacao do comando DEMO                                             *
* Exibe uma demonstracao dos recursos do MINI-LOGO                          *
****************************************************************************/
cmd_stat demo(char *args[])
{
  // Inicia demonstracao...
  while(1)
  {
    execdemo("tat estt 0 mudecl 6 repita 36 [repita 120 [pf 4 pd 3] pe 10]");
    if(!chkcont()) break;

    execdemo("tat estt 1 mudecl 2 repita 90 [repita 3 [pf 120 pe 120] pf 4 pd 4]");
    if(!chkcont()) break;

    execdemo("tat dt mudecl 3 repita 90 [repita 360 [pf 1 pd 1] pf 4 pe 4]");
    if(!chkcont()) break;

    execdemo("tat estt 1 mudecl 4 repita 90 [pd 60 repita 3 [pf 120 pd 120] pe 60 pf 4 pe 4]");
    if(!chkcont()) break;

    execdemo("tat estt 1 mudecl 5 repita 36 [repita 3 [pf 100 pe 15 repita 4[pf 50 pd 90] pe 105] pd 10]");
    if(!chkcont()) break;

    execdemo("tat dt mudecl 5 repita 24 [pd 90 pf 70 pd 30 repita 3 [pf 50 pd 75 repita 4 [pf 30 pe 45 repita 72 [pf 1 pd 5] pe 45] pe 195] pe 30 pt 70 pe 105]");
    if(!chkcont()) break;

    estilo = INIEST;
    parse("tat");
    printline("Fim da demonstracao!!!", SMSG);
    newline();
    break;
  }

  return(S_ok); // Retorna o status ok...
}

/****************************************************************************
* cmd_stat sobre(char *args[])                                              *
*****************************************************************************
* Implementacao do comando SOBRE                                            *
* Exibe os creditos do programa                                             *
****************************************************************************/
cmd_stat sobre(char *args[])
{
  // Exibe as mensagens de creditos e retorna o status ok...
  printline("MINI-LOGO v1.0.0", SMSG);
  printline("Copyright (C) 1999-2008 Willian Mitsuda", SINF);
  printline("O MINI-LOGO nao possui QUALQUER GARANTIA; Ele e software livre e voce esta", SINF);
  printline("convidado a redistribui-lo sob as condicoes da licenca GPL v2.", SINF);
  newline();
  return(S_ok);
}
